home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2007 December / PCWKCD1207B.iso / Blogowanie poza sfera / Flock 1.0 beta / flock-1.0RC3.en-US.win32.exe / flock / components / FeedProcessor.js < prev    next >
Text File  |  2007-10-18  |  63KB  |  1,899 lines
  1. /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
  2. /* ***** BEGIN LICENSE BLOCK *****
  3.  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  4.  *
  5.  * The contents of this file are subject to the Mozilla Public License Version
  6.  * 1.1 (the "License"); you may not use this file except in compliance with
  7.  * the License. You may obtain a copy of the License at
  8.  * http://www.mozilla.org/MPL/
  9.  *
  10.  * Software distributed under the License is distributed on an "AS IS" basis,
  11.  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  12.  * for the specific language governing rights and limitations under the
  13.  * License.
  14.  *
  15.  * The Original Code is mozilla.org code.
  16.  *
  17.  * The Initial Developer of the Original Code is Robert Sayre.
  18.  * Portions created by the Initial Developer are Copyright (C) 2006
  19.  * the Initial Developer. All Rights Reserved.
  20.  *
  21.  * Contributor(s):
  22.  *   Ben Goodger <beng@google.com>
  23.  *   Myk Melez <myk@mozilla.org>
  24.  *
  25.  * Alternatively, the contents of this file may be used under the terms of
  26.  * either the GNU General Public License Version 2 or later (the "GPL"), or
  27.  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  28.  * in which case the provisions of the GPL or the LGPL are applicable instead
  29.  * of those above. If you wish to allow use of your version of this file only
  30.  * under the terms of either the GPL or the LGPL, and not to allow others to
  31.  * use your version of this file under the terms of the MPL, indicate your
  32.  * decision by deleting the provisions above and replace them with the notice
  33.  * and other provisions required by the GPL or the LGPL. If you do not delete
  34.  * the provisions above, a recipient may use your version of this file under
  35.  * the terms of any one of the MPL, the GPL or the LGPL.
  36.  *
  37.  * ***** END LICENSE BLOCK ***** */
  38.  
  39. function LOG(str) {
  40.   dump("*** " + str + "\n");
  41. }
  42.  
  43. const Ci = Components.interfaces;
  44. const Cc = Components.classes;
  45. const Cr = Components.results;
  46.  
  47. const NS_BINDING_ABORTED = 0x804b0002;
  48.  
  49. const IO_CONTRACTID = "@mozilla.org/network/io-service;1"
  50. const BAG_CONTRACTID = "@mozilla.org/hash-property-bag;1"
  51. const ARRAY_CONTRACTID = "@mozilla.org/array;1";
  52. const SAX_CONTRACTID = "@mozilla.org/saxparser/xmlreader;1";
  53. const UNESCAPE_CONTRACTID = "@mozilla.org/feed-unescapehtml;1";
  54.  
  55. var gIoService = Cc[IO_CONTRACTID].getService(Ci.nsIIOService);
  56. var gUnescapeHTML = Cc[UNESCAPE_CONTRACTID].
  57.                     getService(Ci.nsIScriptableUnescapeHTML);
  58.  
  59. const XMLNS = "http://www.w3.org/XML/1998/namespace";
  60. const RSS090NS = "http://my.netscape.com/rdf/simple/0.9/";
  61.  
  62. /***** Some general utils *****/
  63. function strToURI(link, base) {
  64.   var base = base || null;
  65.   try {
  66.     return gIoService.newURI(link, null, base);
  67.   }
  68.   catch(e) {
  69.     return null;
  70.   }
  71. }
  72.  
  73. function isArray(a) {
  74.   return isObject(a) && a.constructor == Array;
  75. }
  76.  
  77. function isObject(a) {
  78.   return (a && typeof a == "object") || isFunction(a);
  79. }
  80.  
  81. function isFunction(a) {
  82.   return typeof a == "function";
  83. }
  84.  
  85. function isIID(a, iid) {
  86.   var rv = false;
  87.   try {
  88.     a.QueryInterface(iid);
  89.     rv = true;
  90.   }
  91.   catch(e) {
  92.   }
  93.   return rv;
  94. }
  95.  
  96. function isIArray(a) {
  97.   return isIID(a, Ci.nsIArray);
  98. }
  99.  
  100. function isIFeedContainer(a) {
  101.   return isIID(a, Ci.nsIFeedContainer);
  102. }
  103.  
  104. function stripTags(someHTML) {
  105.   return someHTML.replace(/<[^>]+>/g,"");
  106. }
  107.  
  108. /**
  109.  * Searches through an array of links and returns a JS array 
  110.  * of matching property bags.
  111.  */
  112. const IANA_URI = "http://www.iana.org/assignments/relation/";
  113. function findAtomLinks(rel, links) {
  114.   var rvLinks = [];
  115.   for (var i = 0; i < links.length; ++i) {
  116.     var linkElement = links.queryElementAt(i, Ci.nsIPropertyBag2);
  117.     // atom:link MUST have @href
  118.     if (bagHasKey(linkElement, "href")) {
  119.       var relAttribute = null;
  120.       if (bagHasKey(linkElement, "rel"))
  121.         relAttribute = linkElement.getPropertyAsAString("rel")
  122.       if ((!relAttribute && rel == "alternate") || relAttribute == rel) {
  123.         rvLinks.push(linkElement);
  124.         continue;
  125.       }
  126.       // catch relations specified by IANA URI 
  127.       if (relAttribute == IANA_URI + rel) {
  128.         rvLinks.push(linkElement);
  129.       }
  130.     }
  131.   }
  132.   return rvLinks;
  133. }
  134.  
  135. function xmlEscape(s) {
  136.   s = s.replace(/&/g, "&");
  137.   s = s.replace(/>/g, ">");
  138.   s = s.replace(/</g, "<");
  139.   s = s.replace(/"/g, """);
  140.   s = s.replace(/'/g, "'");
  141.   return s;
  142. }
  143.  
  144. function arrayContains(array, element) {
  145.   for (var i = 0; i < array.length; ++i) {
  146.     if (array[i] == element) {
  147.       return true;
  148.     }
  149.   }
  150.   return false;
  151. }
  152.  
  153. // XXX add hasKey to nsIPropertyBag
  154. function bagHasKey(bag, key) {
  155.   try {
  156.     bag.getProperty(key);
  157.     return true;
  158.   }
  159.   catch (e) {
  160.     return false;
  161.   }
  162. }
  163.  
  164. function makePropGetter(key) {
  165.   return function FeedPropGetter(bag) {
  166.     try {
  167.       return value = bag.getProperty(key);
  168.     }
  169.     catch(e) {
  170.     }
  171.     return null;
  172.   }
  173. }
  174.  
  175.  
  176.  
  177. /**
  178.  * XXX Thunderbird's W3C-DTF function
  179.  *
  180.  * Converts a W3C-DTF (subset of ISO 8601) date string to an IETF date
  181.  * string.  W3C-DTF is described in this note:
  182.  * http://www.w3.org/TR/NOTE-datetime IETF is obtained via the Date
  183.  * object's toUTCString() method.  The object's toString() method is
  184.  * insufficient because it spells out timezones on Win32
  185.  * (f.e. "Pacific Standard Time" instead of "PST"), which Mail doesn't
  186.  * grok.  For info, see
  187.  * http://lxr.mozilla.org/mozilla/source/js/src/jsdate.c#1526.
  188.  */
  189. const HOURS_TO_MINUTES = 60;
  190. const MINUTES_TO_SECONDS = 60;
  191. const SECONDS_TO_MILLISECONDS = 1000;
  192. const MINUTES_TO_MILLISECONDS = MINUTES_TO_SECONDS * SECONDS_TO_MILLISECONDS;
  193. const HOURS_TO_MILLISECONDS = HOURS_TO_MINUTES * MINUTES_TO_MILLISECONDS;
  194. function W3CToIETFDate(dateString) {
  195.  
  196.   var parts = dateString.match(/(\d{4})(-(\d{2,3}))?(-(\d{2}))?(T(\d{2}):(\d{2})(:(\d{2})(\.(\d+))?)?(Z|([+-])(\d{2}):(\d{2}))?)?/);
  197.  
  198.   // Here's an example of a W3C-DTF date string and what .match returns for it.
  199.   // 
  200.   // date: 2003-05-30T11:18:50.345-08:00
  201.   // date.match returns array values:
  202.   //
  203.   //   0: 2003-05-30T11:18:50-08:00,
  204.   //   1: 2003,
  205.   //   2: -05,
  206.   //   3: 05,
  207.   //   4: -30,
  208.   //   5: 30,
  209.   //   6: T11:18:50-08:00,
  210.   //   7: 11,
  211.   //   8: 18,
  212.   //   9: :50,
  213.   //   10: 50,
  214.   //   11: .345,
  215.   //   12: 345,
  216.   //   13: -08:00,
  217.   //   14: -,
  218.   //   15: 08,
  219.   //   16: 00
  220.  
  221.   // Create a Date object from the date parts.  Note that the Date
  222.   // object apparently can't deal with empty string parameters in lieu
  223.   // of numbers, so optional values (like hours, minutes, seconds, and
  224.   // milliseconds) must be forced to be numbers.
  225.   var date = new Date(parts[1], parts[3] - 1, parts[5], parts[7] || 0,
  226.                       parts[8] || 0, parts[10] || 0, parts[12] || 0);
  227.  
  228.   // We now have a value that the Date object thinks is in the local
  229.   // timezone but which actually represents the date/time in the
  230.   // remote timezone (f.e. the value was "10:00 EST", and we have
  231.   // converted it to "10:00 PST" instead of "07:00 PST").  We need to
  232.   // correct that.  To do so, we're going to add the offset between
  233.   // the remote timezone and UTC (to convert the value to UTC), then
  234.   // add the offset between UTC and the local timezone //(to convert
  235.   // the value to the local timezone).
  236.  
  237.   // Ironically, W3C-DTF gives us the offset between UTC and the
  238.   // remote timezone rather than the other way around, while the
  239.   // getTimezoneOffset() method of a Date object gives us the offset
  240.   // between the local timezone and UTC rather than the other way
  241.   // around.  Both of these are the additive inverse (i.e. -x for x)
  242.   // of what we want, so we have to invert them to use them by
  243.   // multipying by -1 (f.e. if "the offset between UTC and the remote
  244.   // timezone" is -5 hours, then "the offset between the remote
  245.   // timezone and UTC" is -5*-1 = 5 hours).
  246.  
  247.   // Note that if the timezone portion of the date/time string is
  248.   // absent (which violates W3C-DTF, although ISO 8601 allows it), we
  249.   // assume the value to be in UTC.
  250.  
  251.   // The offset between the remote timezone and UTC in milliseconds.
  252.   var remoteToUTCOffset = 0;
  253.   if (parts[13] && parts[13] != "Z") {
  254.     var direction = (parts[14] == "+" ? 1 : -1);
  255.     if (parts[15])
  256.       remoteToUTCOffset += direction * parts[15] * HOURS_TO_MILLISECONDS;
  257.     if (parts[16])
  258.       remoteToUTCOffset += direction * parts[16] * MINUTES_TO_MILLISECONDS;
  259.   }
  260.   remoteToUTCOffset = remoteToUTCOffset * -1; // invert it
  261.  
  262.   // The offset between UTC and the local timezone in milliseconds.
  263.   var UTCToLocalOffset = date.getTimezoneOffset() * MINUTES_TO_MILLISECONDS;
  264.   UTCToLocalOffset = UTCToLocalOffset * -1; // invert it
  265.   date.setTime(date.getTime() + remoteToUTCOffset + UTCToLocalOffset);
  266.  
  267.   return date.toUTCString();
  268. }
  269.  
  270. const RDF_NS = "http://www.w3.org/1999/02/22-rdf-syntax-ns#";
  271. // namespace map
  272. var gNamespaces = {
  273.   "http://webns.net/mvcb/":"admin",
  274.   "http://backend.userland.com/rss":"",
  275.   "http://blogs.law.harvard.edu/tech/rss":"",
  276.   "http://www.w3.org/2005/Atom":"atom",
  277.   "http://purl.org/atom/ns#":"atom03",
  278.   "http://purl.org/rss/1.0/modules/content/":"content",
  279.   "http://purl.org/dc/elements/1.1/":"dc",
  280.   "http://purl.org/dc/terms/":"dcterms",
  281.   "http://www.w3.org/1999/02/22-rdf-syntax-ns#":"rdf",
  282.   "http://purl.org/rss/1.0/":"rss1",
  283.   "http://my.netscape.com/rdf/simple/0.9/":"rss1",
  284.   "http://wellformedweb.org/CommentAPI/":"wfw",                              
  285.   "http://purl.org/rss/1.0/modules/wiki/":"wiki", 
  286.   "http://www.w3.org/XML/1998/namespace":"xml"
  287. }
  288.  
  289.  
  290. function FeedResult() {}
  291. FeedResult.prototype = {
  292.   bozo: false,
  293.   doc: null,
  294.   version: null,
  295.   headers: null,
  296.   uri: null,
  297.   stylesheet: null,
  298.  
  299.   registerExtensionPrefix: function FR_registerExtensionPrefix(ns, prefix) {
  300.     throw Cr.NS_ERROR_NOT_IMPLEMENTED;
  301.   },
  302.  
  303.   QueryInterface: function FR_QI(iid) {
  304.     if (iid.equals(Ci.nsIFeedResult) ||
  305.         iid.equals(Ci.nsISupports))
  306.       return this;
  307.  
  308.     throw Cr.NS_ERROR_NOINTERFACE;
  309.   },
  310. }  
  311.  
  312. function Feed() {
  313.   this.subtitle = null;
  314.   this.title = null;
  315.   this.items = Cc[ARRAY_CONTRACTID].createInstance(Ci.nsIMutableArray);
  316.   this.link = null;
  317.   this.id = null;
  318.   this.generator = null;
  319.   this.authors = Cc[ARRAY_CONTRACTID].createInstance(Ci.nsIMutableArray);
  320.   this.contributors = Cc[ARRAY_CONTRACTID].createInstance(Ci.nsIMutableArray);
  321.   this.baseURI = null;
  322.   this.metadataOnly = false;
  323. }
  324.  
  325. Feed.prototype = {
  326.   searchLists: {
  327.     subtitle: ["description","dc:description","rss1:description",
  328.                "atom03:tagline","atom:subtitle"],
  329.     items: ["items","atom03_entries","entries"],
  330.     id: ["atom:id","rdf:about"],
  331.     generator: ["generator"],
  332.     authors : ["authors"],
  333.     contributors: ["contributors"],
  334.     title: ["title","rss1:title", "atom03:title","atom:title"],
  335.     link:  [["link",strToURI],["rss1:link",strToURI]],
  336.     categories: ["categories", "dc:subject"],
  337.     rights: ["atom03:rights","atom:rights"],
  338.     cloud: ["cloud"],
  339.     image: ["image", "rss1:image", "atom:logo"],
  340.     textInput: ["textInput", "rss1:textinput"],
  341.     skipDays: ["skipDays"],
  342.     skipHours: ["skipHours"],
  343.     updated: ["pubDate", "lastBuildDate", "atom03:modified", "dc:date",
  344.               "dcterms:modified", "atom:updated"]
  345.   },
  346.  
  347.   normalize: function Feed_normalize() {
  348.     fieldsToObj(this, this.searchLists);
  349.     if (this.skipDays)
  350.       this.skipDays = this.skipDays.getProperty("days");
  351.     if (this.skipHours)
  352.       this.skipHours = this.skipHours.getProperty("hours");
  353.  
  354.     if (this.updated)
  355.       this.updated = dateParse(this.updated);
  356.  
  357.     // Assign Atom link if needed
  358.     if (bagHasKey(this.fields, "links"))
  359.       this._atomLinksToURI();
  360.  
  361.     // Resolve relative image links
  362.     if (this.image && bagHasKey(this.image, "url")) {
  363.       this._resolveImageLink();
  364.     }
  365.  
  366.     this._resetBagMembersToRawText([this.searchLists.subtitle, 
  367.                                     this.searchLists.title]);
  368.   },
  369.  
  370.   _atomLinksToURI: function Feed_linkToURI() {
  371.     var links = this.fields.getPropertyAsInterface("links", Ci.nsIArray);
  372.     var alternates = findAtomLinks("alternate", links);
  373.     if (alternates.length > 0) {
  374.       var href = alternates[0].getPropertyAsAString("href");
  375.       var base;
  376.       if (bagHasKey(alternates[0], "xml:base"))
  377.         base = alternates[0].getPropertyAsAString("xml:base");
  378.       this.link = this._resolveURI(href, base);
  379.     }
  380.   },
  381.  
  382.   _resolveImageLink: function Feed_resolveImageLink() {
  383.     var base;
  384.     if (bagHasKey(this.image, "xml:base"))
  385.       base = this.image.getPropertyAsAString("xml:base");
  386.     var url = this._resolveURI(this.image.getPropertyAsAString("url"), base);
  387.     if (url)
  388.       this.image.setPropertyAsAString("url", url.spec);
  389.   },
  390.  
  391.   _resolveURI: function Feed_resolveURI(linkSpec, baseSpec) {
  392.     var uri = null;
  393.     try {
  394.       var base = baseSpec ? strToURI(baseSpec, this.baseURI) : this.baseURI;
  395.       uri = strToURI(linkSpec, base);
  396.     }
  397.     catch(e) {
  398.       LOG(e);
  399.     }
  400.  
  401.     return uri;
  402.   },
  403.  
  404.   // reset the bag to raw contents, not text constructs
  405.   _resetBagMembersToRawText: function Feed_resetBagMembers(fieldLists) {
  406.     for (var i=0; i<fieldLists.length; i++) {      
  407.       for (var j=0; j<fieldLists[i].length; j++) {
  408.         if (bagHasKey(this.fields, fieldLists[i][j])) {
  409.           var textConstruct = this.fields.getProperty(fieldLists[i][j]);
  410.           this.fields.setPropertyAsAString(fieldLists[i][j],
  411.                                            textConstruct.text);
  412.         }
  413.       }
  414.     }
  415.   },
  416.    
  417.   // flockIFeedContainer
  418.   setMetadataOnly: function Feed_setMetadataOnly(metadataOnly) {
  419.     this.metadataOnly = metadataOnly;
  420.   },
  421.  
  422.   QueryInterface: function Feed_QI(iid) {
  423.     if (iid.equals(Ci.nsIFeed) ||
  424.         iid.equals(Ci.flockIFeedContainer) ||
  425.         iid.equals(Ci.nsIFeedContainer) ||
  426.         iid.equals(Ci.nsISupports))
  427.     return this;
  428.     throw Cr.NS_ERROR_NOINTERFACE;
  429.   }
  430. }
  431.  
  432. function Entry() {
  433.   this.summary = null;
  434.   this.content = null;
  435.   this.title = null;
  436.   this.fields = Cc["@mozilla.org/hash-property-bag;1"].
  437.     createInstance(Ci.nsIWritablePropertyBag2);
  438.   this.link = null;
  439.   this.id = null;
  440.   this.baseURI = null;
  441.   this.updated = null;
  442.   this.published = null;
  443.   this.authors = Cc[ARRAY_CONTRACTID].createInstance(Ci.nsIMutableArray);
  444.   this.contributors = Cc[ARRAY_CONTRACTID].createInstance(Ci.nsIMutableArray);
  445. }
  446.   
  447. Entry.prototype = {
  448.   fields: null,
  449.   enclosures: null,
  450.   mediaContent: null,
  451.   
  452.   searchLists: {
  453.     title: ["title", "rss1:title", "atom03:title", "atom:title"],
  454.     link: [["link",strToURI],["rss1:link",strToURI]],
  455.     id: [["guid", makePropGetter("guid")], "rdf:about",
  456.          "atom03:id", "atom:id"],
  457.     authors : ["authors"],
  458.     contributors: ["contributors"],
  459.     summary: ["description", "rss1:description", "dc:description",
  460.               "atom03:summary", "atom:summary"],
  461.     content: ["content:encoded","atom03:content","atom:content"],
  462.     rights: ["atom03:rights","atom:rights"],
  463.     published: ["atom03:issued", "dcterms:issued", "atom:published"],
  464.     updated: ["pubDate", "atom03:modified", "dc:date", "dcterms:modified",
  465.               "atom:updated"]
  466.   },
  467.   
  468.   normalize: function Entry_normalize() {
  469.     fieldsToObj(this, this.searchLists);
  470.  
  471.     // Assign Atom link if needed
  472.     if (bagHasKey(this.fields, "links"))
  473.       this._atomLinksToURI();
  474.  
  475.     // The link might be a guid w/ permalink=true
  476.     if (!this.link && bagHasKey(this.fields, "guid")) {
  477.       var guid = this.fields.getProperty("guid");
  478.       var isPermaLink = true;
  479.       
  480.       if (bagHasKey(guid, "isPermaLink"))
  481.         isPermaLink = guid.getProperty("isPermaLink").toLowerCase() != "false";
  482.       
  483.       if (guid && isPermaLink)
  484.         this.link = strToURI(guid.getProperty("guid"));
  485.     }
  486.  
  487.     if (this.updated)
  488.       this.updated = dateParse(this.updated);
  489.     if (this.published)
  490.       this.published = dateParse(this.published);
  491.  
  492.     this._resetBagMembersToRawText([this.searchLists.content, 
  493.                                     this.searchLists.summary, 
  494.                                     this.searchLists.title]);
  495.   },
  496.   
  497.   QueryInterface: function(iid) {
  498.     if (iid.equals(Ci.nsIFeedEntry) ||
  499.         iid.equals(Ci.nsIFeedContainer) ||
  500.         iid.equals(Ci.nsISupports))
  501.     return this;
  502.  
  503.     throw Cr.NS_ERROR_NOINTERFACE;
  504.   }
  505. }
  506.  
  507. Entry.prototype._atomLinksToURI = Feed.prototype._atomLinksToURI;
  508. Entry.prototype._resolveURI = Feed.prototype._resolveURI;
  509. Entry.prototype._resetBagMembersToRawText = 
  510.    Feed.prototype._resetBagMembersToRawText;
  511.  
  512. // TextConstruct represents and element that could contain (X)HTML
  513. function TextConstruct() {
  514.   this.lang = null;
  515.   this.base = null;
  516.   this.type = "text";
  517.   this.text = null;
  518. }
  519.  
  520. TextConstruct.prototype = {
  521.   plainText: function TC_plainText() {
  522.     if (this.type != "text") {
  523.       if (this.text)
  524.         return gUnescapeHTML.unescape(stripTags(this.text));
  525.       else
  526.         return '';
  527.     }
  528.     return this.text;
  529.   },
  530.  
  531.   createDocumentFragment: function TC_createDocumentFragment(element) {
  532.     if (this.type == "text") {
  533.       var doc = element.ownerDocument;
  534.       var docFragment = doc.createDocumentFragment();
  535.       var node = doc.createTextNode(this.text);
  536.       docFragment.appendChild(node);
  537.       return docFragment;
  538.     }
  539.     var isXML;
  540.     if (this.type == "xhtml")
  541.       isXML = true
  542.     else if (this.type == "html")
  543.       isXML = false;
  544.     else
  545.       return null;
  546.  
  547.     return gUnescapeHTML.parseFragment(this.text, isXML, this.base, element);
  548.   },
  549.  
  550.   QueryInterface: function(iid) {
  551.     if (iid.equals(Ci.nsIFeedTextConstruct) ||
  552.         iid.equals(Ci.nsISupports))
  553.     return this;
  554.  
  555.     throw Cr.NS_ERROR_NOINTERFACE;
  556.   }
  557. }
  558.  
  559. // Generator represents the software that produced the feed
  560. function Generator() {
  561.   this.lang = null;
  562.   this.agent = null;
  563.   this.version = null;
  564.   this.uri = null;
  565.  
  566.   // nsIFeedElementBase
  567.   this._attributes = null;
  568.   this.baseURI = null;
  569. }
  570.  
  571. Generator.prototype = {
  572.  
  573.   get attributes() {
  574.     return this._attributes;
  575.   },
  576.  
  577.   set attributes(value) {
  578.     this._attributes = value;
  579.     this.version = this._attributes.getValueFromName("","version");
  580.     var uriAttribute = this._attributes.getValueFromName("","uri") ||
  581.                        this._attributes.getValueFromName("","url");
  582.     this.uri = strToURI(uriAttribute, this.baseURI);
  583.  
  584.     // RSS1
  585.     uriAttribute = this._attributes.getValueFromName(RDF_NS,"resource");
  586.     if (uriAttribute) {
  587.       this.agent = uriAttribute;
  588.       this.uri = strToURI(uriAttribute, this.baseURI);
  589.     }
  590.   },
  591.  
  592.   QueryInterface: function(iid) {
  593.     if (iid.equals(Ci.nsIFeedGenerator) ||
  594.         iid.equals(Ci.nsIFeedElementBase) ||
  595.         iid.equals(Ci.nsISupports))
  596.     return this;
  597.  
  598.     throw Cr.NS_ERROR_NOINTERFACE;
  599.   }
  600. }
  601.  
  602. function Person() {
  603.   this.name = null;
  604.   this.uri = null;
  605.   this.email = null;
  606.  
  607.   // nsIFeedElementBase
  608.   this.attributes = null;
  609.   this.baseURI = null;
  610. }
  611.  
  612. Person.prototype = {
  613.   QueryInterface: function(iid) {
  614.     if (iid.equals(Ci.nsIFeedPerson) ||
  615.         iid.equals(Ci.nsIFeedElementBase) ||
  616.         iid.equals(Ci.nsISupports))
  617.     return this;
  618.  
  619.     throw Cr.NS_ERROR_NOINTERFACE;
  620.   }
  621. }
  622.  
  623. /** 
  624.  * Map a list of fields into properties on a container.
  625.  *
  626.  * @param container An nsIFeedContainer
  627.  * @param fields A list of fields to search for. List members can
  628.  *               be a list, in which case the second member is 
  629.  *               transformation function (like parseInt).
  630.  */
  631. function fieldsToObj(container, fields) {
  632.   var props,prop,field,searchList;
  633.   for (var key in fields) {
  634.     searchList = fields[key];
  635.     for (var i=0; i < searchList.length; ++i) {
  636.       props = searchList[i];
  637.       prop = null;
  638.       field = isArray(props) ? props[0] : props;
  639.       try {
  640.         prop = container.fields.getProperty(field);
  641.       } 
  642.       catch(e) { 
  643.       }
  644.       if (prop) {
  645.         prop = isArray(props) ? props[1](prop) : prop;
  646.         container[key] = prop;
  647.       }
  648.     }
  649.   }
  650. }
  651.  
  652. /**
  653.  * Lower cases an element's localName property
  654.  * @param   element A DOM element.
  655.  *
  656.  * @returns The lower case localName property of the specified element
  657.  */
  658. function LC(element) {
  659.   return element.localName.toLowerCase();
  660. }
  661.  
  662. // TODO move these post-processor functions
  663. // create a generator element
  664. function atomGenerator(s, generator) {
  665.   generator.QueryInterface(Ci.nsIFeedGenerator);
  666.   generator.agent = trimString(s);
  667.   return generator;
  668. }
  669.  
  670. // post-process atom:logo to create an RSS2-like structure
  671. function atomLogo(s, logo) {
  672.   logo.setPropertyAsAString("url", trimString(s));
  673. }
  674.  
  675. // post-process an RSS category, map it to the Atom fields.
  676. function rssCatTerm(s, cat) {
  677.   // add slash handling?
  678.   cat.setPropertyAsAString("term", trimString(s));
  679.   return cat;
  680. } 
  681.  
  682. // post-process a GUID 
  683. function rssGuid(s, guid) {
  684.   guid.setPropertyAsAString("guid", trimString(s));
  685.   return guid;
  686. }
  687.  
  688. // post-process an RSS author element
  689. //
  690. // It can contain a field like this:
  691. // 
  692. //  <author>lawyer@boyer.net (Lawyer Boyer)</author>
  693. //
  694. // or, delightfully, a field like this:
  695. //
  696. //  <dc:creator>Simon St.Laurent (mailto:simonstl@simonstl.com)</dc:creator>
  697. //
  698. // We want to split this up and assign it to corresponding Atom
  699. // fields.
  700. //
  701. function rssAuthor(s,author) {
  702.   author.QueryInterface(Ci.nsIFeedPerson);
  703.   // check for RSS2 string format
  704.   var chars = trimString(s);
  705.   var matches = chars.match(/(.*)\((.*)\)/);
  706.   var emailCheck = 
  707.     /^([a-zA-Z0-9_\.\-])+\@(([a-zA-Z0-9\-])+\.)+([a-zA-Z0-9]{2,4})+$/;
  708.   if (matches) {
  709.     var match1 = trimString(matches[1]);
  710.     var match2 = trimString(matches[2]);
  711.     if (match2.indexOf("mailto:") == 0)
  712.       match2 = match2.substring(7);
  713.     if (emailCheck.test(match1)) {
  714.       author.email = match1;
  715.       author.name = match2;
  716.     }
  717.     else if (emailCheck.test(match2)) {
  718.       author.email = match2;
  719.       author.name = match1;
  720.     }
  721.     else {
  722.       // put it back together
  723.       author.name = match1 + " (" + match2 + ")";
  724.     }
  725.   }
  726.   else {
  727.     author.name = chars;
  728.     if (chars.indexOf('@'))
  729.       author.email = chars;
  730.   }
  731.   return author;
  732. }
  733.  
  734. //
  735. // skipHours and skipDays map to arrays, so we need to change the
  736. // string to an nsISupports in order to stick it in there.
  737. //
  738. function rssArrayElement(s) {
  739.   var str = Cc["@mozilla.org/supports-string;1"].
  740.               createInstance(Ci.nsISupportsString);
  741.   str.data = s;
  742.   str.QueryInterface(Ci.nsISupportsString);
  743.   return str;
  744. }
  745.  
  746. /***** Some feed utils from TBird *****/
  747.  
  748. /**
  749.  * Tests a RFC822 date against a regex.
  750.  * @param aDateStr A string to test as an RFC822 date.
  751.  *
  752.  * @returns A boolean indicating whether the string is a valid RFC822 date.
  753.  */
  754. function isValidRFC822Date(aDateStr) {
  755.   var regex = new RegExp(RFC822_RE);
  756.   return regex.test(aDateStr);
  757. }
  758.  
  759. /**
  760.  * Removes leading and trailing whitespace from a string.
  761.  * @param s The string to trim.
  762.  *
  763.  * @returns A new string with whitespace stripped.
  764.  */
  765. function trimString(s) {
  766.   return(s.replace(/^\s+/, "").replace(/\s+$/, ""));
  767. }
  768.  
  769. // Regular expression matching RFC822 dates 
  770. const RFC822_RE = "^(((Mon)|(Tue)|(Wed)|(Thu)|(Fri)|(Sat)|(Sun)), *)?\\d\\d?"
  771. + " +((Jan)|(Feb)|(Mar)|(Apr)|(May)|(Jun)|(Jul)|(Aug)|(Sep)|(Oct)|(Nov)|(Dec))"
  772. + " +\\d\\d(\\d\\d)? +\\d\\d:\\d\\d(:\\d\\d)? +(([+-]?\\d\\d\\d\\d)|(UT)|(GMT)"
  773. + "|(EST)|(EDT)|(CST)|(CDT)|(MST)|(MDT)|(PST)|(PDT)|\\w)$";
  774.  
  775. /**
  776.  * XXX -- need to decide what this should return. 
  777.  * XXX -- Is there a Date class usable from C++?
  778.  *
  779.  * Tries tries parsing various date formats.
  780.  * @param dateString
  781.  *        A string that is supposedly an RFC822 or RFC3339 date.
  782.  * @returns A Date.toString XXX--fixme
  783.  */
  784. function dateParse(dateString) {
  785.   var date = trimString(dateString);
  786.  
  787.   if (date.search(/^\d\d\d\d/) != -1) //Could be a ISO8601/W3C date
  788.     return W3CToIETFDate(dateString);
  789.  
  790.   if (isValidRFC822Date(date))
  791.     return date; 
  792.   
  793.   if (!isNaN(parseInt(date, 10))) { 
  794.     //It's an integer, so maybe it's a timestamp
  795.     var d = new Date(parseInt(date, 10) * 1000);
  796.     var now = new Date();
  797.     var yeardiff = now.getFullYear() - d.getFullYear();
  798.     if ((yeardiff >= 0) && (yeardiff < 3)) {
  799.       // it's quite likely the correct date. 3 years is an arbitrary cutoff,
  800.       // but this is an invalid date format, and there's no way to verify
  801.       // its correctness.
  802.       return d.toString();
  803.     }
  804.   }
  805.   // Can't help.
  806.   return null;
  807. } 
  808.  
  809.  
  810. const XHTML_NS = "http://www.w3.org/1999/xhtml";
  811.  
  812. // The XHTMLHandler handles inline XHTML found in things like atom:summary
  813. function XHTMLHandler(processor, isAtom) {
  814.   this._buf = "";
  815.   this._processor = processor;
  816.   this._depth = 0;
  817.   this._isAtom = isAtom;
  818. }
  819.  
  820. // The fidelity can be improved here, to allow handling of stuff like
  821. // SVG and MathML. XXX
  822. XHTMLHandler.prototype = {
  823.   startDocument: function XH_startDocument() {
  824.   },
  825.   endDocument: function XH_endDocument() {
  826.   },
  827.   startElement: function XH_startElement(uri, localName, qName, attributes) {
  828.     ++this._depth;
  829.  
  830.     // RFC4287 requires XHTML to be wrapped in a div that is *not* part of 
  831.     // the content. This prevents people from screwing up namespaces, but
  832.     // we need to skip it here.
  833.     if (this._isAtom && this._depth == 1 && localName == "div")
  834.       return;
  835.  
  836.     // If it's an XHTML element, record it. Otherwise, it's ignored.
  837.     if (uri == XHTML_NS) {
  838.       this._buf += "<" + localName;
  839.       for (var i=0; i < attributes.length; ++i) {
  840.         // XHTML attributes aren't in a namespace
  841.         if (attributes.getURI(i) == "") { 
  842.           this._buf += (" " + attributes.getLocalName(i) + "='" +
  843.                         xmlEscape(attributes.getValue(i)) + "'");
  844.         }
  845.       }
  846.       this._buf += ">";
  847.     }
  848.   },
  849.   endElement: function XH_endElement(uri, localName, qName) {
  850.     --this._depth;
  851.     
  852.     // We need to skip outer divs in Atom. See comment in startElement.
  853.     if (this._isAtom && this._depth == 0 && localName == "div")
  854.       return;
  855.  
  856.     // When we peek too far, go back to the main processor
  857.     if (this._depth < 0) {
  858.       this._processor.returnFromXHTMLHandler(trimString(this._buf),
  859.                                              uri, localName, qName);
  860.       return;
  861.     }
  862.     // If it's an XHTML element, record it. Otherwise, it's ignored.
  863.     if (uri == XHTML_NS) {
  864.       this._buf += "</" + localName + ">";
  865.     }
  866.   },
  867.   characters: function XH_characters(data) {
  868.     this._buf += xmlEscape(data);
  869.   },
  870.   startPrefixMapping: function XH_startPrefixMapping() {
  871.   },
  872.   endPrefixMapping: function XH_endPrefixMapping() {
  873.   },
  874.   processingInstruction: function XH_processingInstruction() {
  875.   }, 
  876. }
  877.  
  878. /**
  879.  * The ExtensionHandler deals with elements we haven't explicitly
  880.  * added to our transition table in the FeedProcessor.
  881.  */
  882. function ExtensionHandler(processor) {
  883.   this._buf = "";
  884.   this._depth = 0;
  885.   this._hasChildElements = false;
  886.  
  887.   // The FeedProcessor
  888.   this._processor = processor;
  889.  
  890.   // Fields of the outermost extension element.
  891.   this._localName = null;
  892.   this._uri = null;
  893.   this._qName = null;
  894.   this._attrs = null;
  895. }
  896.  
  897. ExtensionHandler.prototype = {
  898.   startDocument: function EH_startDocument() {
  899.   },
  900.   endDocument: function EH_endDocument() {
  901.   },
  902.   startElement: function EH_startElement(uri, localName, qName, attrs) {
  903.     ++this._depth;
  904.     var prefix = gNamespaces[uri] ? gNamespaces[uri] + ":" : "";
  905.     var key =  prefix + localName;
  906.     
  907.     if (this._depth == 1) {
  908.       this._uri = uri;
  909.       this._localName = localName;
  910.       this._qName = qName;
  911.       this._attrs = attrs;
  912.     }
  913.     
  914.     // if we descend into another element, we won't send text
  915.     this._hasChildElements = (this._depth > 1);
  916.     
  917.   },
  918.   endElement: function EH_endElement(uri, localName, qName) {
  919.     --this._depth;
  920.     if (this._depth == 0) {
  921.       var text = this._hasChildElements ? null : trimString(this._buf);
  922.       this._processor.returnFromExtHandler(this._uri, this._localName, 
  923.                                            text, this._attrs);
  924.     }
  925.   },
  926.   characters: function EH_characters(data) {
  927.     if (!this._hasChildElements)
  928.       this._buf += data;
  929.   },
  930.   startPrefixMapping: function EH_startPrefixMapping() {
  931.   },
  932.   endPrefixMapping: function EH_endPrefixMapping() {
  933.   },
  934.   processingInstruction: function EH_processingInstruction() {
  935.   }, 
  936. };
  937.  
  938.  
  939. /**
  940.  * ElementInfo is a simple container object that describes
  941.  * some characteristics of a feed element. For example, it
  942.  * says whether an element can be expected to appear more
  943.  * than once inside a given entry or feed.
  944.  */ 
  945. function ElementInfo(fieldName, containerClass, closeFunc, isArray) {
  946.   this.fieldName = fieldName;
  947.   this.containerClass = containerClass;
  948.   this.closeFunc = closeFunc;
  949.   this.isArray = isArray;
  950.   this.isWrapper = false;
  951. }
  952.  
  953. /**
  954.  * FeedElementInfo represents a feed element, usually the root.
  955.  */
  956. function FeedElementInfo(fieldName, feedVersion) {
  957.   this.isWrapper = false;
  958.   this.fieldName = fieldName;
  959.   this.feedVersion = feedVersion;
  960. }
  961.  
  962. /**
  963.  * Some feed formats include vestigial wrapper elements that we don't
  964.  * want to include in our object model, but we do need to keep track
  965.  * of during parsing.
  966.  */
  967. function WrapperElementInfo(fieldName) {
  968.   this.isWrapper = true;
  969.   this.fieldName = fieldName;
  970. }
  971.  
  972. /***** The Processor *****/
  973. function FeedProcessor() {
  974.   this._reader = Cc[SAX_CONTRACTID].createInstance(Ci.nsISAXXMLReader);
  975.   this._buf =  "";
  976.   this._feed = Cc[BAG_CONTRACTID].createInstance(Ci.nsIWritablePropertyBag2);
  977.   this._handlerStack = [];
  978.   this._xmlBaseStack = []; // sparse array keyed to nesting depth
  979.   this._depth = 0;
  980.   this._state = "START";
  981.   this._result = null;
  982.   this._extensionHandler = null;
  983.   this._xhtmlHandler = null;
  984.  
  985.   // The nsIFeedResultListener waiting for the parse results
  986.   this.listener = null;
  987.  
  988.   // These elements can contain (X)HTML or plain text.
  989.   // We keep a table here that contains their default treatment
  990.   this._textConstructs = {"atom:title":"text",
  991.                           "atom:summary":"text",
  992.                           "atom:rights":"text",
  993.                           "atom:content":"text",
  994.                           "atom:subtitle":"text",
  995.                           "description":"html",
  996.                           "rss1:description":"html",
  997.                           "dc:description":"html",
  998.                           "content:encoded":"html",
  999.                           "title":"text",
  1000.                           "rss1:title":"text",
  1001.                           "atom03:title":"text",
  1002.                           "atom03:tagline":"text",
  1003.                           "atom03:summary":"text",
  1004.                           "atom03:content":"text"};
  1005.   this._stack = [];
  1006.  
  1007.   this._trans = {   
  1008.     "START": {
  1009.       //If we hit a root RSS element, treat as RSS2.
  1010.       "rss": new FeedElementInfo("RSS2", "rss2"),
  1011.  
  1012.       // If we hit an RDF element, if could be RSS1, but we can't
  1013.       // verify that until we hit a rss1:channel element.
  1014.       "rdf:RDF": new WrapperElementInfo("RDF"),
  1015.  
  1016.       // If we hit a Atom 1.0 element, treat as Atom 1.0.
  1017.       "atom:feed": new FeedElementInfo("Atom", "atom"),
  1018.  
  1019.       // Treat as Atom 0.3
  1020.       "atom03:feed": new FeedElementInfo("Atom03", "atom03"),
  1021.     },
  1022.     
  1023.     /********* RSS2 **********/
  1024.     "IN_RSS2": {
  1025.       "channel": new WrapperElementInfo("channel")
  1026.     },
  1027.  
  1028.     "IN_CHANNEL": {
  1029.       "item": new ElementInfo("items", Cc[ENTRY_CONTRACTID], null, true),
  1030.       "managingEditor": new ElementInfo("authors", Cc[PERSON_CONTRACTID],
  1031.                                         rssAuthor, true),
  1032.       "dc:creator": new ElementInfo("authors", Cc[PERSON_CONTRACTID],
  1033.                                     rssAuthor, true),
  1034.       "dc:author": new ElementInfo("authors", Cc[PERSON_CONTRACTID],
  1035.                                    rssAuthor, true),
  1036.       "dc:contributor": new ElementInfo("contributors", Cc[PERSON_CONTRACTID],
  1037.                                          rssAuthor, true),
  1038.       "category": new ElementInfo("categories", null, rssCatTerm, true),
  1039.       "cloud": new ElementInfo("cloud", null, null, false),
  1040.       "image": new ElementInfo("image", null, null, false),
  1041.       "textInput": new ElementInfo("textInput", null, null, false),
  1042.       "skipDays": new ElementInfo("skipDays", null, null, false),
  1043.       "skipHours": new ElementInfo("skipHours", null, null, false),
  1044.       "generator": new ElementInfo("generator", Cc[GENERATOR_CONTRACTID],
  1045.                                    atomGenerator, false),
  1046.     },
  1047.  
  1048.     "IN_ITEMS": {
  1049.       "author": new ElementInfo("authors", Cc[PERSON_CONTRACTID],
  1050.                                 rssAuthor, true),
  1051.       "dc:creator": new ElementInfo("authors", Cc[PERSON_CONTRACTID],
  1052.                                     rssAuthor, true),
  1053.       "dc:author": new ElementInfo("authors", Cc[PERSON_CONTRACTID],
  1054.                                    rssAuthor, true),
  1055.       "dc:contributor": new ElementInfo("contributors", Cc[PERSON_CONTRACTID],
  1056.                                          rssAuthor, true),
  1057.       "category": new ElementInfo("categories", null, rssCatTerm, true),
  1058.       "enclosure": new ElementInfo("enclosure", null, null, true),
  1059.       "guid": new ElementInfo("guid", null, rssGuid, false)
  1060.     },
  1061.  
  1062.     "IN_SKIPDAYS": {
  1063.       "day": new ElementInfo("days", null, rssArrayElement, true)
  1064.     },
  1065.  
  1066.     "IN_SKIPHOURS":{
  1067.       "hour": new ElementInfo("hours", null, rssArrayElement, true)
  1068.     },
  1069.  
  1070.     /********* RSS1 **********/
  1071.     "IN_RDF": {
  1072.       // If we hit a rss1:channel, we can verify that we have RSS1
  1073.       "rss1:channel": new FeedElementInfo("rdf_channel", "rss1"),
  1074.       "rss1:image": new ElementInfo("image", null, null, false),
  1075.       "rss1:textinput": new ElementInfo("textInput", null, null, false),
  1076.       "rss1:item": new ElementInfo("items", Cc[ENTRY_CONTRACTID], null, true),
  1077.     },
  1078.  
  1079.     "IN_RDF_CHANNEL": {
  1080.       "admin:generatorAgent": new ElementInfo("generator",
  1081.                                               Cc[GENERATOR_CONTRACTID],
  1082.                                               null, false),
  1083.       "dc:creator": new ElementInfo("authors", Cc[PERSON_CONTRACTID],
  1084.                                     rssAuthor, true),
  1085.       "dc:author": new ElementInfo("authors", Cc[PERSON_CONTRACTID],
  1086.                                    rssAuthor, true),
  1087.       "dc:contributor": new ElementInfo("contributors", Cc[PERSON_CONTRACTID],
  1088.                                          rssAuthor, true),
  1089.     },
  1090.  
  1091.     /********* ATOM 1.0 **********/
  1092.     "IN_ATOM": {
  1093.       "atom:author": new ElementInfo("authors", Cc[PERSON_CONTRACTID],
  1094.                                      null, true),
  1095.       "atom:generator": new ElementInfo("generator", Cc[GENERATOR_CONTRACTID],
  1096.                                         atomGenerator, false),
  1097.       "atom:contributor": new ElementInfo("contributors",  Cc[PERSON_CONTRACTID],
  1098.                                           null, true),
  1099.       "atom:link": new ElementInfo("links", null, null, true),
  1100.       "atom:logo": new ElementInfo("atom:logo", null, atomLogo, false),
  1101.       "atom:entry": new ElementInfo("entries", Cc[ENTRY_CONTRACTID],
  1102.                                     null, true)
  1103.     },
  1104.  
  1105.     "IN_ENTRIES": {
  1106.       "atom:author": new ElementInfo("authors", Cc[PERSON_CONTRACTID],
  1107.                                      null, true),
  1108.       "atom:contributor": new ElementInfo("contributors", Cc[PERSON_CONTRACTID],
  1109.                                           null, true),
  1110.       "atom:link": new ElementInfo("links", null, null, true),
  1111.     },
  1112.  
  1113.     /********* ATOM 0.3 **********/
  1114.     "IN_ATOM03": {
  1115.       "atom03:author": new ElementInfo("authors", Cc[PERSON_CONTRACTID],
  1116.                                        null, true),
  1117.       "atom03:contributor": new ElementInfo("contributors",
  1118.                                             Cc[PERSON_CONTRACTID],
  1119.                                             null, true),
  1120.       "atom03:link": new ElementInfo("links", null, null, true),
  1121.       "atom03:entry": new ElementInfo("atom03_entries", Cc[ENTRY_CONTRACTID],
  1122.                                       null, true),
  1123.       "atom03:generator": new ElementInfo("generator", Cc[GENERATOR_CONTRACTID],
  1124.                                           atomGenerator, false),
  1125.     },
  1126.  
  1127.     "IN_ATOM03_ENTRIES": {
  1128.       "atom03:author": new ElementInfo("authors", Cc[PERSON_CONTRACTID],
  1129.                                        null, true),
  1130.       "atom03:contributor": new ElementInfo("contributors",
  1131.                                             Cc[PERSON_CONTRACTID],
  1132.                                             null, true),
  1133.       "atom03:link": new ElementInfo("links", null, null, true),
  1134.       "atom03:entry": new ElementInfo("atom03_entries", Cc[ENTRY_CONTRACTID],
  1135.                                       null, true)
  1136.     }
  1137.   }
  1138. }
  1139.  
  1140. // See startElement for a long description of how feeds are processed.
  1141. FeedProcessor.prototype = { 
  1142.   
  1143.   // Set ourselves as the SAX handler, and set the base URI
  1144.   _init: function FP_init(uri, metadataOnly) {
  1145.     this._reader.contentHandler = this;
  1146.     this._reader.errorHandler = this;
  1147.     this._result = Cc[FR_CONTRACTID].createInstance(Ci.nsIFeedResult);
  1148.     this._metadataOnly = metadataOnly;
  1149.     this._sentResult = false;
  1150.     if (uri) {
  1151.       this._result.uri = uri;
  1152.       this._reader.baseURI = uri;
  1153.       this._xmlBaseStack[0] = uri;
  1154.     }
  1155.   },
  1156.  
  1157.   // This function is called once we figure out what type of feed
  1158.   // we're dealing with. Some feed types require digging a bit further
  1159.   // than the root.
  1160.   _docVerified: function FP_docVerified(version) {
  1161.     this._result.doc = Cc[FEED_CONTRACTID].createInstance(Ci.nsIFeed);
  1162.     this._result.doc.baseURI = 
  1163.       this._xmlBaseStack[this._xmlBaseStack.length - 1];
  1164.     this._result.doc.fields = this._feed;
  1165.     this._result.version = version;
  1166.   },
  1167.  
  1168.   // When we're done with the feed, let the listener know what
  1169.   // happened.
  1170.   _sendResult: function FP_sendResult(cleanup) {
  1171.     if (!this._sentResult) {
  1172.       var feed = this._result.doc;
  1173.  
  1174.       try {
  1175.         // Can be null when a non-feed is fed to us
  1176.         if (feed)
  1177.           feed.normalize();
  1178.       }
  1179.       catch (e) {
  1180.         LOG("FIXME: " + e);
  1181.       }
  1182.  
  1183.       if (feed && this._metadataOnly) {
  1184.         feed.items.clear();
  1185.  
  1186.         var flockFeed = feed.QueryInterface(Ci.flockIFeedContainer);
  1187.         flockFeed.setMetadataOnly(true);
  1188.       }
  1189.  
  1190.       try {
  1191.         if (this.listener != null)
  1192.           this.listener.handleResult(this._result);
  1193.       }
  1194.       catch (e) { }
  1195.     }
  1196.  
  1197.     this._sentResult = true;
  1198.  
  1199.     if (cleanup) {
  1200.       this._result = null;
  1201.       this._reader = null;
  1202.     }
  1203.   },
  1204.  
  1205.   _maybeSendMetadata: function FP_maybeSendMetadata(request) {
  1206.     var dataReady = false;
  1207.  
  1208.     if (!this._result)
  1209.       return;
  1210.  
  1211.     var feed = this._result.doc;
  1212.  
  1213.     try {
  1214.       if (feed) {
  1215.         var searchList = ["title","rss1:title", "atom03:title","atom:title"];
  1216.         for each (var field in searchList) {
  1217.           var prop = null;
  1218.           try {
  1219.             prop = feed.fields.getProperty(field);
  1220.           }
  1221.           catch (e) { }
  1222.           if (prop) {
  1223.             dataReady = true;
  1224.             break;
  1225.           }
  1226.         }
  1227.       }
  1228.     }
  1229.     catch (e) {
  1230.       LOG("FIXME: " + e);
  1231.     }
  1232.  
  1233.     if (dataReady) {
  1234.       this._sendResult(false);
  1235.       request.cancel(NS_BINDING_ABORTED);
  1236.     }
  1237.   },
  1238.  
  1239.   // Parsing functions
  1240.   parseFromStream: function FP_parseFromStream(stream, uri) {
  1241.     this._init(uri, false);
  1242.     this._reader.parseFromStream(stream, null, stream.available(), 
  1243.                                  "application/xml");
  1244.     this._reader = null;
  1245.   },
  1246.  
  1247.   parseFromString: function FP_parseFromString(inputString, uri) {
  1248.     this._init(uri, false);
  1249.     this._reader.parseFromString(inputString, "application/xml");
  1250.     this._reader = null;
  1251.   },
  1252.  
  1253.   parseAsync: function FP_parseAsync(requestObserver, uri) {
  1254.     this._init(uri, false);
  1255.     this._reader.parseAsync(requestObserver);
  1256.   },
  1257.  
  1258.   // flockIFeedProcessor
  1259.   parseFeedMetadataAsync: function FP_parseFeedMetadataAsync(requestObserver, uri) {
  1260.     this._init(uri, true);
  1261.     this._reader.parseAsync(requestObserver);
  1262.   },
  1263.  
  1264.   // nsIStreamListener 
  1265.  
  1266.   // The XMLReader will throw sensible exceptions if these get called
  1267.   // out of order.
  1268.   onStartRequest: function FP_onStartRequest(request, context) {
  1269.     this._reader.onStartRequest(request, context);
  1270.   },
  1271.  
  1272.   onStopRequest: function FP_onStopRequest(request, context, statusCode) {
  1273.     this._reader.onStopRequest(request, context, statusCode);
  1274.   },
  1275.  
  1276.   onDataAvailable:
  1277.   function FP_onDataAvailable(request, context, inputStream, offset, count) {
  1278.     this._reader.onDataAvailable(request, context, inputStream, offset, count);
  1279.  
  1280.     if (this._metadataOnly)
  1281.       this._maybeSendMetadata(request);
  1282.   },
  1283.  
  1284.   // nsISAXErrorHandler
  1285.  
  1286.   // We only care about fatal errors. When this happens, we may have
  1287.   // parsed through the feed metadata and some number of entries. The
  1288.   // listener can still show some of that data if it wants, and we'll
  1289.   // set the bozo bit to indicate we were unable to parse all the way
  1290.   // through.
  1291.   fatalError: function FP_reportError() {
  1292.     this._result.bozo = true;
  1293.     //XXX need to QI to FeedProgressListener
  1294.     this._sendResult(true);
  1295.   },
  1296.  
  1297.   // nsISAXContentHandler
  1298.  
  1299.   startDocument: function FP_startDocument() {
  1300.     //LOG("----------");
  1301.   },
  1302.  
  1303.   endDocument: function FP_endDocument() {
  1304.     this._sendResult(true);
  1305.   },
  1306.  
  1307.   // The transitions defined above identify elements that contain more
  1308.   // than just text. For example RSS items contain many fields, and so
  1309.   // do Atom authors. The only commonly used elements that contain
  1310.   // mixed content are Atom Text Constructs of type="xhtml", which we
  1311.   // delegate to another handler for cleaning. That leaves a couple
  1312.   // different types of elements to deal with: those that should occur
  1313.   // only once, such as title elements, and those that can occur
  1314.   // multiple times, such as the RSS category element and the Atom
  1315.   // link element. Most of the RSS1/DC elements can occur multiple
  1316.   // times in theory, but in practice, the only ones that do have
  1317.   // analogues in Atom. 
  1318.   //
  1319.   // Some elements are also groups of attributes or sub-elements,
  1320.   // while others are simple text fields. For the most part, we don't
  1321.   // have to pay explicit attention to the simple text elements,
  1322.   // unless we want to post-process the resulting string to transform
  1323.   // it into some richer object like a Date or URI.
  1324.   //
  1325.   // Elements that have more sophisticated content models still end up
  1326.   // being dictionaries, whether they are based on attributes like RSS
  1327.   // cloud, sub-elements like Atom author, or even items and
  1328.   // entries. These elements are treated as "containers". It's
  1329.   // theoretically possible for a container to have an attribute with 
  1330.   // the same universal name as a sub-element, but none of the feed
  1331.   // formats allow this by default, and I don't of any extension that
  1332.   // works this way.
  1333.   //
  1334.   startElement: function FP_startElement(uri, localName, qName, attributes) {
  1335.     this._buf = "";
  1336.     ++this._depth;
  1337.     var elementInfo;
  1338.  
  1339.     //LOG("<" + localName + ">");
  1340.  
  1341.     // Check for xml:base
  1342.     var base = attributes.getValueFromName(XMLNS, "base");
  1343.     if (base) {
  1344.       this._xmlBaseStack[this._depth] =
  1345.         strToURI(base, this._xmlBaseStack[this._xmlBaseStack.length - 1]);
  1346.     }
  1347.  
  1348.     // To identify the element we're dealing with, we look up the
  1349.     // namespace URI in our gNamespaces dictionary, which will give us
  1350.     // a "canonical" prefix for a namespace URI. For example, this
  1351.     // allows Dublin Core "creator" elements to be consistently mapped
  1352.     // to "dc:creator", for easy field access by consumer code. This
  1353.     // strategy also happens to shorten up our state table.
  1354.     var key =  this._prefixForNS(uri) + localName;
  1355.  
  1356.     // Check to see if we need to hand this off to our XHTML handler.
  1357.     // The elements we're dealing with will look like this:
  1358.     // 
  1359.     // <title type="xhtml">
  1360.     //   <div xmlns="http://www.w3.org/1999/xhtml">
  1361.     //     A title with <b>bold</b> and <i>italics</i>.
  1362.     //   </div>
  1363.     // </title>
  1364.     //
  1365.     // When it returns in returnFromXHTMLHandler, the handler should
  1366.     // give us back a string like this: 
  1367.     // 
  1368.     //    "A title with <b>bold</b> and <i>italics</i>."
  1369.     //
  1370.     // The Atom spec explicitly says the div is not part of the content,
  1371.     // and explicitly allows whitespace collapsing.
  1372.     // 
  1373.     if ((this._result.version == "atom" || this._result.version == "atom03") &&
  1374.         this._textConstructs[key] != null) {
  1375.       var type = attributes.getValueFromName("","type");
  1376.       if (type != null && type.indexOf("xhtml") >= 0) {
  1377.         this._xhtmlHandler = 
  1378.           new XHTMLHandler(this, (this._result.version == "atom"));
  1379.         this._reader.contentHandler = this._xhtmlHandler;
  1380.         return;
  1381.       }
  1382.     }
  1383.  
  1384.     // Check our current state, and see if that state has a defined
  1385.     // transition. For example, this._trans["atom:entry"]["atom:author"]
  1386.     // will have one, and it tells us to add an item to our authors array.
  1387.     if (this._trans[this._state] && this._trans[this._state][key]) {
  1388.       elementInfo = this._trans[this._state][key];
  1389.     }
  1390.     else {
  1391.       // If we don't have a transition, hand off to extension handler
  1392.       this._extensionHandler = new ExtensionHandler(this);
  1393.       this._reader.contentHandler = this._extensionHandler;
  1394.       this._extensionHandler.startElement(uri, localName, qName, attributes);
  1395.       return;
  1396.     }
  1397.       
  1398.     // This distinguishes wrappers like 'channel' from elements
  1399.     // we'd actually like to do something with (which will test true).
  1400.     this._handlerStack[this._depth] = elementInfo; 
  1401.     if (elementInfo.isWrapper) {
  1402.       this._state = "IN_" + elementInfo.fieldName.toUpperCase();
  1403.       this._stack.push([this._feed, this._state]);
  1404.     } 
  1405.     else if (elementInfo.feedVersion) {
  1406.       this._state = "IN_" + elementInfo.fieldName.toUpperCase();
  1407.  
  1408.       // Check for the older RSS2 variants
  1409.       if (elementInfo.feedVersion == "rss2")
  1410.         elementInfo.feedVersion = this._findRSSVersion(attributes);
  1411.       else if (uri == RSS090NS)
  1412.         elementInfo.feedVersion = "rss090";
  1413.  
  1414.       this._docVerified(elementInfo.feedVersion);
  1415.       this._stack.push([this._feed, this._state]);
  1416.       this._mapAttributes(this._feed, attributes);
  1417.     }
  1418.     else {
  1419.       this._state = this._processComplexElement(elementInfo, attributes);
  1420.     }
  1421.   },
  1422.  
  1423.   // In the endElement handler, we decrement the stack and look
  1424.   // for cleanup/transition functions to execute. The second part
  1425.   // of the state transition works as above in startElement, but
  1426.   // the state we're looking for is prefixed with an underscore
  1427.   // to distinguish endElement events from startElement events.
  1428.   endElement:  function FP_endElement(uri, localName, qName) {
  1429.     var elementInfo = this._handlerStack[this._depth];
  1430.     //LOG("</" + localName + ">");
  1431.     if (elementInfo && !elementInfo.isWrapper)
  1432.       this._closeComplexElement(elementInfo);
  1433.   
  1434.     // cut down xml:base context
  1435.     if (this._xmlBaseStack.length == this._depth + 1)
  1436.       this._xmlBaseStack = this._xmlBaseStack.slice(0, this._depth);
  1437.  
  1438.     // our new state is whatever is at the top of the stack now
  1439.     if (this._stack.length > 0)
  1440.       this._state = this._stack[this._stack.length - 1][1];
  1441.     this._handlerStack = this._handlerStack.slice(0, this._depth);
  1442.     --this._depth;
  1443.   },
  1444.  
  1445.   // Buffer up character data. The buffer is cleared with every
  1446.   // opening element.
  1447.   characters: function FP_characters(data) {
  1448.     this._buf += data;
  1449.   },
  1450.  
  1451.   // TODO: It would be nice to check new prefixes here, and if they
  1452.   // don't conflict with the ones we've defined, throw them in a 
  1453.   // dictionary to check.
  1454.   startPrefixMapping: function FP_startPrefixMapping() {
  1455.   },
  1456.   endPrefixMapping: function FP_endPrefixMapping() {
  1457.   },
  1458.   processingInstruction: function FP_processingInstruction(target, data) {
  1459.     if (target == "xml-stylesheet") {
  1460.       var hrefAttribute = data.match(/href=[\"\'](.*?)[\"\']/);
  1461.       if (hrefAttribute && hrefAttribute.length == 2) 
  1462.         this._result.stylesheet = gIoService.newURI(hrefAttribute[1], null,
  1463.                                                     this._result.uri);
  1464.     }
  1465.   },
  1466.  
  1467.   // end of nsISAXContentHandler
  1468.  
  1469.   // Handle our more complicated elements--those that contain
  1470.   // attributes and child elements.
  1471.   _processComplexElement:
  1472.   function FP__processComplexElement(elementInfo, attributes) {
  1473.     var obj, key, prefix;
  1474.  
  1475.     // If the container is an entry/item, it'll need to have its 
  1476.     // more esoteric properties put in the 'fields' property bag.
  1477.     if (elementInfo.containerClass == Cc[ENTRY_CONTRACTID]) {
  1478.       obj = elementInfo.containerClass.createInstance(Ci.nsIFeedEntry);
  1479.       obj.baseURI = this._xmlBaseStack[this._xmlBaseStack.length - 1];
  1480.       this._mapAttributes(obj.fields, attributes);
  1481.     }
  1482.     else if (elementInfo.containerClass) {
  1483.       obj = elementInfo.containerClass.createInstance(Ci.nsIFeedElementBase);
  1484.       obj.baseURI = this._xmlBaseStack[this._xmlBaseStack.length - 1];
  1485.       obj.attributes = attributes; // just set the SAX attributes
  1486.     }
  1487.     else {
  1488.       obj = Cc[BAG_CONTRACTID].createInstance(Ci.nsIWritablePropertyBag2);
  1489.       this._mapAttributes(obj, attributes);
  1490.     }
  1491.  
  1492.     // We should have a container/propertyBag that's had its
  1493.     // attributes processed. Now we need to attach it to its
  1494.     // container.
  1495.     var newProp;
  1496.  
  1497.     // First we'll see what's on top of the stack.
  1498.     var container = this._stack[this._stack.length - 1][0];
  1499.  
  1500.     // Check to see if it has the property
  1501.     var prop;
  1502.     try {
  1503.       prop = container.getProperty(elementInfo.fieldName);
  1504.     }
  1505.     catch(e) {
  1506.     }
  1507.     
  1508.     if (elementInfo.isArray) {
  1509.       if (!prop) {
  1510.         container.setPropertyAsInterface(elementInfo.fieldName,
  1511.                                          Cc[ARRAY_CONTRACTID].
  1512.                                          createInstance(Ci.nsIMutableArray));
  1513.       }
  1514.  
  1515.       newProp = container.getProperty(elementInfo.fieldName);
  1516.       // XXX This QI should not be necessary, but XPConnect seems to fly
  1517.       // off the handle in the browser, and loses track of the interface
  1518.       // on large files. Bug 335638.
  1519.       newProp.QueryInterface(Ci.nsIMutableArray);
  1520.       newProp.appendElement(obj,false);
  1521.       
  1522.       // If new object is an nsIFeedContainer, we want to deal with
  1523.       // its member nsIPropertyBag instead.
  1524.       if (isIFeedContainer(obj))
  1525.         newProp = obj.fields; 
  1526.  
  1527.     }
  1528.     else {
  1529.       // If it doesn't, set it.
  1530.       if (!prop) {
  1531.         container.setPropertyAsInterface(elementInfo.fieldName,obj);
  1532.       }
  1533.       newProp = container.getProperty(elementInfo.fieldName);
  1534.     }
  1535.     
  1536.     // make our new state name, and push the property onto the stack
  1537.     var newState = "IN_" + elementInfo.fieldName.toUpperCase();
  1538.     this._stack.push([newProp, newState, obj]);
  1539.     return newState;
  1540.   },
  1541.  
  1542.   // Sometimes we need reconcile the element content with the object
  1543.   // model for a given feed. We use helper functions to do the
  1544.   // munging, but we need to identify array types here, so the munging
  1545.   // happens only to the last element of an array.
  1546.   _closeComplexElement: function FP__closeComplexElement(elementInfo) {
  1547.     var stateTuple = this._stack.pop();
  1548.     var container = stateTuple[0];
  1549.     var containerParent = stateTuple[2];
  1550.     var element = null;
  1551.     var isArray = isIArray(container);
  1552.  
  1553.     // If it's an array and we have to post-process,
  1554.     // grab the last element
  1555.     if (isArray)
  1556.       element = container.queryElementAt(container.length - 1, Ci.nsISupports);
  1557.     else
  1558.       element = container;
  1559.  
  1560.     // Run the post-processing function if there is one.
  1561.     if (elementInfo.closeFunc)
  1562.       element = elementInfo.closeFunc(this._buf, element);
  1563.  
  1564.     // If an nsIFeedContainer was on top of the stack,
  1565.     // we need to normalize it
  1566.     if (elementInfo.containerClass == Cc[ENTRY_CONTRACTID])
  1567.       containerParent.normalize();
  1568.  
  1569.     // If it's an array, re-set the last element
  1570.     if (isArray)
  1571.       container.replaceElementAt(element, container.length - 1, false);
  1572.   },
  1573.   
  1574.   _prefixForNS: function FP_prefixForNS(uri) {
  1575.     if (!uri)
  1576.       return "";
  1577.     var prefix = gNamespaces[uri];
  1578.     if (prefix)
  1579.       return prefix + ":";
  1580.     if (uri.toLowerCase().indexOf("http://backend.userland.com") == 0)
  1581.       return "";
  1582.     else
  1583.       return null;
  1584.   },
  1585.  
  1586.   _mapAttributes: function FP__mapAttributes(bag, attributes) {
  1587.     // Cycle through the attributes, and set our properties using the
  1588.     // prefix:localNames we find in our namespace dictionary.
  1589.     for (var i = 0; i < attributes.length; ++i) {
  1590.       var key = this._prefixForNS(attributes.getURI(i)) + attributes.getLocalName(i);
  1591.       var val = attributes.getValue(i);
  1592.       bag.setPropertyAsAString(key, val);
  1593.     }
  1594.   },
  1595.  
  1596.   // Only for RSS2esque formats
  1597.   _findRSSVersion: function FP__findRSSVersion(attributes) {
  1598.     var versionAttr = trimString(attributes.getValueFromName("", "version"));
  1599.     var versions = { "0.91":"rss091",
  1600.                      "0.92":"rss092",
  1601.                      "0.93":"rss093",
  1602.                      "0.94":"rss094" }
  1603.     if (versions[versionAttr])
  1604.       return versions[versionAttr];
  1605.     if (versionAttr.substr(0,2) != "2.")
  1606.       return "rssUnknown";
  1607.     return "rss2";
  1608.   },
  1609.  
  1610.   // unknown element values are returned here. See startElement above
  1611.   // for how this works.
  1612.   returnFromExtHandler:
  1613.   function FP_returnExt(uri, localName, chars, attributes) {
  1614.     --this._depth;
  1615.  
  1616.     // take control of the SAX events
  1617.     this._reader.contentHandler = this;
  1618.     if (localName == null && chars == null)
  1619.       return;
  1620.  
  1621.     // we don't take random elements inside rdf:RDF
  1622.     if (this._state == "IN_RDF")
  1623.       return;
  1624.     
  1625.     // Grab the top of the stack
  1626.     var top = this._stack[this._stack.length - 1];
  1627.     if (!top) 
  1628.       return;
  1629.  
  1630.     var container = top[0];
  1631.     // Grab the last element if it's an array
  1632.     if (isIArray(container)) {
  1633.       var contract = this._handlerStack[this._depth].containerClass;
  1634.       // check if it's something specific, but not an entry
  1635.       if (contract && contract != Cc[ENTRY_CONTRACTID]) {
  1636.         var el = container.queryElementAt(container.length - 1, 
  1637.                                           Ci.nsIFeedElementBase);
  1638.         // XXX there must be a way to flatten these interfaces
  1639.         if (contract == Cc[PERSON_CONTRACTID]) 
  1640.           el.QueryInterface(Ci.nsIFeedPerson);
  1641.         else
  1642.           return; // don't know about this interface
  1643.  
  1644.         var propName = localName;
  1645.         var prefix = gNamespaces[uri];
  1646.  
  1647.         // synonyms
  1648.         if ((uri == "" || 
  1649.              prefix &&
  1650.              ((prefix.indexOf("atom") > -1) ||
  1651.               (prefix.indexOf("rss") > -1))) && 
  1652.             (propName == "url" || propName == "href"))
  1653.           propName = "uri";
  1654.         
  1655.         try {
  1656.           if (el[propName] !== "undefined") {
  1657.             var propValue = chars;
  1658.             // convert URI-bearing values to an nsIURI
  1659.             if (propName == "uri") {
  1660.               var base = this._xmlBaseStack[this._xmlBaseStack.length - 1];
  1661.               propValue = strToURI(chars, base);
  1662.             }
  1663.             el[propName] = propValue;
  1664.           }
  1665.         }
  1666.         catch(e) {
  1667.           // ignore XPConnect errors
  1668.         }
  1669.         // the rest of the function deals with entry- and feed-level stuff
  1670.         return; 
  1671.       } 
  1672.       else {
  1673.         container = container.queryElementAt(container.length - 1, 
  1674.                                              Ci.nsIWritablePropertyBag2);
  1675.       }
  1676.     }
  1677.     
  1678.     // Make the buffer our new property
  1679.     var propName = this._prefixForNS(uri) + localName;
  1680.  
  1681.     // But, it could be something containing HTML. If so,
  1682.     // we need to know about that.
  1683.     if (this._textConstructs[propName] != null &&
  1684.         this._handlerStack[this._depth].containerClass !== null) {
  1685.       var newProp = Cc[TEXTCONSTRUCT_CONTRACTID].
  1686.                     createInstance(Ci.nsIFeedTextConstruct);
  1687.       newProp.text = chars;
  1688.       // Look up the default type in our table
  1689.       var type = this._textConstructs[propName];
  1690.       var typeAttribute = attributes.getValueFromName("","type");
  1691.       if (this._result.version == "atom" && typeAttribute != null) {
  1692.         type = typeAttribute;
  1693.       }
  1694.       else if (this._result.version == "atom03" && typeAttribute != null) {
  1695.         if (typeAttribute.toLowerCase().indexOf("xhtml") >= 0) {
  1696.           type = "xhtml";
  1697.         }
  1698.         else if (typeAttribute.toLowerCase().indexOf("html") >= 0) {
  1699.           type = "html";
  1700.         }
  1701.         else if (typeAttribute.toLowerCase().indexOf("text") >= 0) {
  1702.           type = "text";
  1703.         }
  1704.       }
  1705.       
  1706.       // If it's rss feed-level description, it's not supposed to have html
  1707.       if (this._result.version.indexOf("rss") >= 0 &&
  1708.           this._handlerStack[this._depth].containerClass != ENTRY_CONTRACTID) {
  1709.         type = "text";
  1710.       }
  1711.  
  1712.       newProp.type = type;
  1713.       newProp.base = this._xmlBaseStack[this._xmlBaseStack.length - 1];
  1714.       container.setPropertyAsInterface(propName, newProp);
  1715.     }
  1716.     else {
  1717.       container.setPropertyAsAString(propName, chars);
  1718.     }
  1719.     
  1720.   },
  1721.  
  1722.   // Sometimes, we'll hand off SAX handling duties to an XHTMLHandler
  1723.   // (see above) that will scrape out non-XHTML stuff, normalize
  1724.   // namespaces, and remove the wrapper div from Atom 1.0. When the
  1725.   // XHTMLHandler is done, it'll callback here.
  1726.   returnFromXHTMLHandler:
  1727.   function FP_returnFromXHTMLHandler(chars, uri, localName, qName) {
  1728.     // retake control of the SAX content events
  1729.     this._reader.contentHandler = this;
  1730.  
  1731.     // Grab the top of the stack
  1732.     var top = this._stack[this._stack.length - 1];
  1733.     if (!top) 
  1734.       return;
  1735.     var container = top[0];
  1736.  
  1737.     // Assign the property
  1738.     var newProp =  newProp = Cc[TEXTCONSTRUCT_CONTRACTID].
  1739.                    createInstance(Ci.nsIFeedTextConstruct);
  1740.     newProp.text = chars;
  1741.     newProp.type = "xhtml";
  1742.     newProp.base = this._xmlBaseStack[this._xmlBaseStack.length - 1];
  1743.     container.setPropertyAsInterface(this._prefixForNS(uri) + localName,
  1744.                                      newProp);
  1745.     
  1746.     // XHTML will cause us to peek too far. The XHTML handler will
  1747.     // send us an end element to call. RFC4287-valid feeds allow a
  1748.     // more graceful way to handle this. Unfortunately, we can't count
  1749.     // on compliance at this point.
  1750.     this.endElement(uri, localName, qName);
  1751.   },
  1752.  
  1753.   // nsISupports
  1754.   QueryInterface: function FP_QueryInterface(iid) {
  1755.     if (iid.equals(Ci.nsIFeedProcessor) ||
  1756.         iid.equals(Ci.flockIFeedProcessor) ||
  1757.         iid.equals(Ci.nsISAXContentHandler) ||
  1758.         iid.equals(Ci.nsISAXErrorHandler) ||
  1759.         iid.equals(Ci.nsIStreamListener) ||
  1760.         iid.equals(Ci.nsIRequestObserver) ||
  1761.         iid.equals(Ci.nsISupports))
  1762.       return this;
  1763.  
  1764.     throw Cr.NS_ERROR_NOINTERFACE;
  1765.   },
  1766. }
  1767.  
  1768. const FP_CONTRACTID = "@mozilla.org/feed-processor;1";
  1769. const FP_CLASSID = Components.ID("{26acb1f0-28fc-43bc-867a-a46aabc85dd4}");
  1770. const FP_CLASSNAME = "Feed Processor";
  1771. const FR_CONTRACTID = "@mozilla.org/feed-result;1";
  1772. const FR_CLASSID = Components.ID("{072a5c3d-30c6-4f07-b87f-9f63d51403f2}");
  1773. const FR_CLASSNAME = "Feed Result";
  1774. const FEED_CONTRACTID = "@mozilla.org/feed;1";
  1775. const FEED_CLASSID = Components.ID("{5d0cfa97-69dd-4e5e-ac84-f253162e8f9a}");
  1776. const FEED_CLASSNAME = "Feed";
  1777. const ENTRY_CONTRACTID = "@mozilla.org/feed-entry;1";
  1778. const ENTRY_CLASSID = Components.ID("{8e4444ff-8e99-4bdd-aa7f-fb3c1c77319f}");
  1779. const ENTRY_CLASSNAME = "Feed Entry";
  1780. const TEXTCONSTRUCT_CONTRACTID = "@mozilla.org/feed-textconstruct;1";
  1781. const TEXTCONSTRUCT_CLASSID =
  1782.   Components.ID("{b992ddcd-3899-4320-9909-924b3e72c922}");
  1783. const TEXTCONSTRUCT_CLASSNAME = "Feed Text Construct";
  1784. const GENERATOR_CONTRACTID = "@mozilla.org/feed-generator;1";
  1785. const GENERATOR_CLASSID =
  1786.   Components.ID("{414af362-9ad8-4296-898e-62247f25a20e}");
  1787. const GENERATOR_CLASSNAME = "Feed Generator";
  1788. const PERSON_CONTRACTID = "@mozilla.org/feed-person;1";
  1789. const PERSON_CLASSID = Components.ID("{95c963b7-20b2-11db-92f6-001422106990}");
  1790. const PERSON_CLASSNAME = "Feed Person";
  1791.  
  1792. function GenericComponentFactory(ctor) {
  1793.   this._ctor = ctor;
  1794. }
  1795.  
  1796. GenericComponentFactory.prototype = {
  1797.  
  1798.   _ctor: null,
  1799.  
  1800.   // nsIFactory
  1801.   createInstance: function(outer, iid) {
  1802.     if (outer != null)
  1803.       throw Cr.NS_ERROR_NO_AGGREGATION;
  1804.     return (new this._ctor()).QueryInterface(iid);
  1805.   },
  1806.  
  1807.   // nsISupports
  1808.   QueryInterface: function(iid) {
  1809.     if (iid.equals(Ci.nsIFactory) ||
  1810.         iid.equals(Ci.nsISupports))
  1811.       return this;
  1812.     throw Cr.NS_ERROR_NO_INTERFACE;
  1813.   },
  1814.  
  1815. };
  1816.  
  1817. var Module = {
  1818.   QueryInterface: function(iid) {
  1819.     if (iid.equals(Ci.nsIModule) || 
  1820.         iid.equals(Ci.nsISupports))
  1821.       return this;
  1822.  
  1823.     throw Cr.NS_ERROR_NO_INTERFACE;
  1824.   },
  1825.  
  1826.   getClassObject: function(cm, cid, iid) {
  1827.     if (!iid.equals(Ci.nsIFactory))
  1828.       throw Cr.NS_ERROR_NOT_IMPLEMENTED;
  1829.  
  1830.     if (cid.equals(FP_CLASSID))
  1831.       return new GenericComponentFactory(FeedProcessor);
  1832.     if (cid.equals(FR_CLASSID))
  1833.       return new GenericComponentFactory(FeedResult);
  1834.     if (cid.equals(FEED_CLASSID))
  1835.       return new GenericComponentFactory(Feed);
  1836.     if (cid.equals(ENTRY_CLASSID))
  1837.       return new GenericComponentFactory(Entry);
  1838.     if (cid.equals(TEXTCONSTRUCT_CLASSID))
  1839.       return new GenericComponentFactory(TextConstruct);
  1840.     if (cid.equals(GENERATOR_CLASSID))
  1841.       return new GenericComponentFactory(Generator);
  1842.     if (cid.equals(PERSON_CLASSID))
  1843.       return new GenericComponentFactory(Person);
  1844.  
  1845.     throw Cr.NS_ERROR_NO_INTERFACE;
  1846.   },
  1847.  
  1848.   registerSelf: function(cm, file, location, type) {
  1849.     var cr = cm.QueryInterface(Ci.nsIComponentRegistrar);
  1850.     // Feed Processor
  1851.     cr.registerFactoryLocation(FP_CLASSID, FP_CLASSNAME,
  1852.       FP_CONTRACTID, file, location, type);
  1853.     // Feed Result
  1854.     cr.registerFactoryLocation(FR_CLASSID, FR_CLASSNAME,
  1855.       FR_CONTRACTID, file, location, type);
  1856.     // Feed
  1857.     cr.registerFactoryLocation(FEED_CLASSID, FEED_CLASSNAME,
  1858.       FEED_CONTRACTID, file, location, type);
  1859.     // Entry
  1860.     cr.registerFactoryLocation(ENTRY_CLASSID, ENTRY_CLASSNAME,
  1861.       ENTRY_CONTRACTID, file, location, type);
  1862.     // Text Construct
  1863.     cr.registerFactoryLocation(TEXTCONSTRUCT_CLASSID, TEXTCONSTRUCT_CLASSNAME,
  1864.       TEXTCONSTRUCT_CONTRACTID, file, location, type);
  1865.     // Generator
  1866.     cr.registerFactoryLocation(GENERATOR_CLASSID, GENERATOR_CLASSNAME,
  1867.       GENERATOR_CONTRACTID, file, location, type);
  1868.     // Person
  1869.     cr.registerFactoryLocation(PERSON_CLASSID, PERSON_CLASSNAME,
  1870.       PERSON_CONTRACTID, file, location, type);
  1871.   },
  1872.  
  1873.   unregisterSelf: function(cm, location, type) {
  1874.     var cr = cm.QueryInterface(Ci.nsIComponentRegistrar);
  1875.     // Feed Processor
  1876.     cr.unregisterFactoryLocation(FP_CLASSID, location);
  1877.     // Feed Result
  1878.     cr.unregisterFactoryLocation(FR_CLASSID, location);
  1879.     // Feed
  1880.     cr.unregisterFactoryLocation(FEED_CLASSID, location);
  1881.     // Entry
  1882.     cr.unregisterFactoryLocation(ENTRY_CLASSID, location);
  1883.     // Text Construct
  1884.     cr.unregisterFactoryLocation(TEXTCONSTRUCT_CLASSID, location);
  1885.     // Generator
  1886.     cr.unregisterFactoryLocation(GENERATOR_CLASSID, location);
  1887.     // Person
  1888.     cr.unregisterFactoryLocation(PERSON_CLASSID, location);
  1889.   },
  1890.  
  1891.   canUnload: function(cm) {
  1892.     return true;
  1893.   },
  1894. };
  1895.  
  1896. function NSGetModule(cm, file) {
  1897.   return Module;
  1898. }
  1899.